[clang-cl] Support the /JMC flag

[ychen]

Summary

The introduction and some examples are on this page:
https://devblogs.microsoft.com/cppblog/announcing-jmc-stepping-in-visual-studio/

The /JMC flag enables these instrumentations:

• Insert at the beginning of every function immediately after the prologue with a call to void __fastcall __CheckForDebuggerJustMyCode(unsigned char *JMC_flag). The argument for __CheckForDebuggerJustMyCode is the address of a boolean global variable (the global variable is initialized to 1) with the name convention __<hash>_<filename>. All such global variables are placed in the .msvcjmc section.
• The <hash> part of __<hash>_<filename> has a one-to-one mapping with a directory path. MSVC uses some unknown hashing function. Here I used DJB.
• Add a dummy/empty COMDAT function __JustMyCode_Default.
• Add /alternatename:__CheckForDebuggerJustMyCode=__JustMyCode_Default link option via ".drectve" section. This is to prevent failure in case __CheckForDebuggerJustMyCode is not provided during linking.

Implementation:
All the instrumentations are implemented in an IR codegen pass. The pass is placed immediately before CodeGenPrepare pass. This is to not interfere with mid-end optimizations and make the instrumentation target-independent (I'm still working on an ELF port in a separate patch).

[ychen]

• update

[aganea]

Cool! :) Seems good generally.
Sounds like an expensive flag for the runtime perf :-D But I guess it makes the debugging experience a bit nicer.

clang/lib/Driver/ToolChains/Clang.cpp

7494

Can we do here if (*EmitCodeView && *DebugInfoKind >= codegenoptions::DebugInfoConstructor)? Is it worth introducing a new variable?

clang/test/Driver/cl-options.c

782

Perhaps add a test %clang_cl /JMC /JMC-

llvm/lib/CodeGen/JMCInstrumenter.cpp

132

s/options/option/

[ychen]

Thanks a lot for reviewing the patch!

In D118428#3281721, @aganea wrote:

Cool! :) Seems good generally.
Sounds like an expensive flag for the runtime perf :-D But I guess it makes the debugging experience a bit nicer.

Exactly. I had the same thoughts. For MSVC it is what it is. For ELF, the other choice from using the same scheme as MSVC is that we could inline the __CheckForDebuggerJustMyCode call (its definition is here: https://github.com/ojdkbuild/tools_toolchain_vs2017bt_1416/blob/master/VC/Tools/MSVC/14.16.27023/crt/src/vcruntime/debugger_jmc.c) before the function ABI prologue. For example, to instrument a function _foo:

  andb r11l, _jmc_global_flag, _jmc_enable_per_thread_step
  andb r11l, r11, _jmc_per_module_flag
  andb r11l, r11, _jmc_per_file_flag
  cmpb r11l, 0
  jne _foo 
  int 3
_foo:

The parameter of __CheckForDebuggerJustMyCode is _jmc_per_file_flag above. int 3 is basically a per-function flag. _jmc_per_module_flag and _jmc_global_flag control the JMC behavior at module-level or program-level for better performance. Otherwise, the debugger needs the gather this information using debuginfo. This scheme is target-dependent and increases the .text slightly. But it eliminates the call and the flag modification at different granularity is fast. With that being said, experts working on ELF debuggers have ideas about which scheme is better. I'll send an RFC for ELF after this patch goes in.

clang/lib/Driver/ToolChains/Clang.cpp

7494

Yeah, I think that works better. No need for a new variable.

[ychen]

• address Alexandre's comments

[hans]

This is great stuff, thanks!

clang/docs/ReleaseNotes.rst

84

The cc1 flag is more of an implementation detail, so not sure it's worth mentioning in the release notes. Or do we want "clang -fjmc" to work?

clang/include/clang/Driver/Options.td

6370

I'm not sure "native C/C++" adds much info in the context of clang. Maybe just "Enable Just My Code debugging" is enough?

(Also, how do we want to spell this? Other features are not typically capitalized in clang.. so maybe "enable just my code debugging" or "enable just-my-code debugging"?)

clang/lib/Driver/ToolChains/Clang.cpp

7496

Why that level specifically and not e.g. *DebugInfoKind > NoDebugInfo?

clang/test/Driver/cl-options.c

775

• is missing from this run line?

779

It seemed odd to me that the JMC check prefix is used for tests which check that JMC is *not* enabled.

How about using "NOJMC" for these, and "JMC" for the test below where it's enabled?

llvm/lib/CodeGen/CommandFlags.cpp

469

Other "on/off" options don't seem to have "enable" in the name or flag spelling, e.g. "-strict-dwarf", not "-enable-strict-dwarf". Maybe this should be just "-jmc-instrument" and JMCInstrument?

llvm/lib/CodeGen/JMCInstrumenter.cpp

19

Is that necessary? I assume nothing interesting would get scheduled across such a call anyway?

67

I don't think we'd want to call realpath or GetFullPathName() as some builds may want to use relative paths, or paths with a specific prefix (see the -fdebug-compilation-dir flag)

76

Should probably point out here (or below) that we're not using the same hash as MSVC.

112

What's the purpose of the default check function? Doesn't the CRT always provide one? (And if it doesn't, will JMC work at all?)

144

What if there are no function definitions in the module? In that case, I think we would not have created the function declaration, and this assert would fail?

I think instead of this micro-optimization, it would be safer set the function attributes etc. when creating the decl, and cache it. It could be a lambda in runOnModule() or maybe a helper method in the class with a member variable to hold the cached decl?

Or it could even just be declared outside the main loop in runOnModule() and in the loop you could do

if (!CheckFunction) {
  CheckFunction = ...
  add attributes and stuff
}

157

if this and EntryAttr can't change, maybe they should be const, and maybe declared outside the function?

158

That's a very x86 specific check. What about other targets? (Also the calling conventions are x86 specific..)

169

Do other instrumentation passes consume the attr like this? Why would the pass run again?

Actually it looks like the code does the opposite of consuming: it looks for the attribute, and *adds* it if it's not there..

175

As mentioned above, the decl could be cached instead, there's no need to look it up each time.

176

Hashing is cheap, but since we're likely to use the same filename again and again, and it does take some string manipulation, maybe caching the result is a good idea. Actually, could we cache the flag Constant rather than the name?

183

I thought static linkage meant they all go into the binary.. how do you mean one of them wins and the others are dead?

191

is the appendToUsed necessary? It will be used by the call instruction (and if that goes away for some reason, I guess we'd want the variable to go away too?)

llvm/test/CodeGen/X86/jmc-instrument-32bit.ll

2 ↗

(On Diff #404307)

Mixing opt and llc testing like this seems unusual. The pass is really an instrumentation pass, so I suppose llvm/test/Instrumentation/ would be a better place, and I don't think the llc test is needed?

[aganea]

clang/docs/ReleaseNotes.rst

84

@ychen @hans An additional question is whether we want to use the same cc1 flag for an potential ELF port?

clang/lib/Driver/ToolChains/Clang.cpp

7496

@hans MSVC does this check too, not sure why.

D:\git\llvm-project>cl main.cpp /c /JMC
Microsoft (R) C/C++ Optimizing Compiler Version 19.29.30139 for ARM64
Copyright (C) Microsoft Corporation.  All rights reserved.

cl : Command line warning D9007 : '/JMC' requires '/Zi, /ZI or /Z7'; option ignored
main.cpp

llvm/lib/CodeGen/JMCInstrumenter.cpp

112

@hans That's what MSVC does, to avoid a linker error if the CRT isn't linked in:

D:\git\llvm-project>cat main.cpp
int main() { }
D:\git\llvm-project>cl main.cpp /JMC /Z7 /c
Microsoft (R) C/C++ Optimizing Compiler Version 19.29.30139 for x64
Copyright (C) Microsoft Corporation.  All rights reserved.

main.cpp

D:\git\llvm-project>dumpbin /disasm main.obj
Microsoft (R) COFF/PE Dumper Version 14.29.30139.0
Copyright (C) Microsoft Corporation.  All rights reserved.


Dump of file main.obj

File Type: COFF OBJECT

main:
  0000000000000000: 48 83 EC 28        sub         rsp,28h
  0000000000000004: 48 8D 0D 00 00 00  lea         rcx,[__BB04C4AD_main@cpp]
                    00
  000000000000000B: E8 00 00 00 00     call        __CheckForDebuggerJustMyCode
  0000000000000010: 33 C0              xor         eax,eax
  0000000000000012: 48 83 C4 28        add         rsp,28h
  0000000000000016: C3                 ret

__JustMyCode_Default:
  0000000000000000: C2 00 00           ret         0

  Summary

          50 .chks64
         228 .debug$S
         3EC .debug$T
          70 .drectve
           1 .msvcjmc
           C .pdata
          1A .text$mn
           8 .xdata

D:\git\llvm-project>dumpbin /all main.obj | grep -B12 -A5 'COMDAT; sym= __JustMyCode_Default'
SECTION HEADER #5
.text$mn name
       0 physical address
       0 virtual address
       3 size of raw data
     438 file pointer to raw data (00000438 to 0000043A)
       0 file pointer to relocation table
       0 file pointer to line numbers
       0 number of relocations
       0 number of line numbers
60501020 flags
         Code
         COMDAT; sym= __JustMyCode_Default
         16 byte align
         Execute Read

RAW DATA #5
  00000000: C2 00 00                                         □..

158

@ychen Worth nothing that /JMC works on ARM/ARM64 as well. Should we support that too, not sure that's what @hans is implying?

D:\git\llvm-project>cl main.cpp /c /JMC /Z7
Microsoft (R) C/C++ Optimizing Compiler Version 19.29.30139 for ARM64
Copyright (C) Microsoft Corporation.  All rights reserved.

main.cpp

D:\git\llvm-project>dumpbin /disasm main.obj
Microsoft (R) COFF/PE Dumper Version 14.29.30139.0
Copyright (C) Microsoft Corporation.  All rights reserved.


Dump of file main.obj

File Type: COFF OBJECT

main:
  0000000000000000: A9BF7BFD  stp         fp,lr,[sp,#-0x10]!
  0000000000000004: 910003FD  mov         fp,sp
  0000000000000008: 90000008  adrp        x8,__BB04C4AD_main@cpp
  000000000000000C: 91000100  add         x0,x8,__BB04C4AD_main@cpp
  0000000000000010: 94000000  bl          __CheckForDebuggerJustMyCode
  0000000000000014: 52800000  mov         w0,#0
  0000000000000018: A8C17BFD  ldp         fp,lr,[sp],#0x10
  000000000000001C: D65F03C0  ret

__JustMyCode_Default:
  0000000000000000: D65F03C0  ret

  Summary

          48 .chks64
         228 .debug$S
         3F0 .debug$T
          70 .drectve
           1 .msvcjmc
           8 .pdata
          24 .text$mn

[ychen]

• address hans's comments

[ychen]

@hans @aganea I think all comments are addressed except that I don't know how to test the ARM/ARM64 JMC function (I don't have ARM hardware or is there any ARM-based Windows virtual machine?). PTAL.

clang/docs/ReleaseNotes.rst

84

Removed. Yeah, I think "clang -fjmc" for an ELF implementation makes sense.

clang/include/clang/Driver/Options.td

6370

Used "enable just-my-code debugging"

clang/lib/Driver/ToolChains/Clang.cpp

7496

I think it needs enough debug info to enable MSVC stepping. The ones < DebugInfoConstructor seems not sufficient but I'm entirely sure.

llvm/lib/CodeGen/CommandFlags.cpp

469

The "-jmc-instrument" is already used by the pass itself (#define DEBUG_TYPE "jmc-instrument"). The DEBUG_TYPE one enables opt -jmc-instrument; this makes llc -enable-jmc-instrument to run the pass in IR codegen pipeline.

Just renamed cl::opt<bool> EnableJMCInstrument to cl::opt<bool> JMCInstrument.

llvm/lib/CodeGen/JMCInstrumenter.cpp

19

Agreed that in practice, it is not very likely to cause trouble. But I still think it is nice to have.

Removed the TODO. Make it a comment down below.

67

Yep, missed that. Comments updated.

76

yep. Updated the comment here.

144

End up using a lambda in runOnModule().

157

Yes, they don't change. Made them const and move them into the anonymous namespace above.

158

That's a very x86 specific check. What about other targets? (Also the calling conventions are x86 specific..)

Is32Bit -> UseFastCall to make it explicit. Only X86 should use this.

@aganea it turns out ARM should just work. I'll add tests for ARM.

169

Initially, I put this pass at the end of the mid-end optimization pipeline which may have this issue for LTO, etc. Now, this pass is in IR CodeGen pipeline. I don't think this is needed anymore. Removed.

176

Yep, used DenseMap<DISubprogram *, Constant *>.

183

Sorry for the confusion. I meant that they all go into the binary, but only one of the bytes is used at run time. Not that they are dead or stripped at linker time.

191

Removed. I was afraid that the internal-linkage flags could get removed since they have no users. But they get their address taken by external-linkage __CheckForDebuggerJustMyCode, so yeah, no need mark them used.

llvm/test/CodeGen/X86/jmc-instrument-32bit.ll

2 ↗

(On Diff #404307)

There is a codegen change to make flag symbols not qualified. Hence the llc test.

Make the llc test smaller and move opt tests to llvm/test/Instrumentation.

[hans]

llvm/lib/CodeGen/CommandFlags.cpp

469

Maybe the fact that -jmc-instrument is used by the IR pass is a hint that there shouldn't be an llc option for this, then? Looking at the other options here, they're all about codegen features, whereas the instrumentation in this patch really happens at a higher level.

llvm/lib/CodeGen/JMCInstrumenter.cpp

112

Thanks, I see. Doing the same as MSVC seems fine, but I'm curious why they chose this approach.. as far as I understand, JMC will not work for the binary in this scenario, so avoiding the link error is not obviously better.

146

I still worry a bit about the target-specific code here. Normally, IR passes don't have any target-specific knowledge, but ask classes such as TargetTransformInfo for target-specific details, or possibly take them as input to the pass. For example, see llvm/lib/Transforms/CFGuard/CFGuard.cpp

I'm also not sure that lib/CodeGen/ is the right place for this pass, since most files there seem to be machine-IR passes. Maybe the natural place for this would be lib/Transforms/Instrumentation/? Is there some good pass we can compare this with?

148

This kind of mutable lambda feels pretty subtle to me. I think something like the below would be more straight-forward.

Function *CheckFunction = nullptr;
for (...) {
  ...
  if (!CheckFunction) {
    // Create the decl here.
  }
}

But if you strongly prefer the lambda, I suppose it's okay.

164

Same comment as for the lambda above. I think it would be more straight-forward to just keep the DenseMap outside the loop and just put the code to use/create the Constant in the loop.

176

Nice!

llvm/test/CodeGen/X86/jmc-instrument.ll

2 ↗

(On Diff #404805)

Since it's an IR pass, I think we don't need to have an llc test at all.

[ychen]

• address comments

llvm/lib/CodeGen/CommandFlags.cpp

469

There are three kinds of passes (each in a separate pipeline), in the order of execution: IR optimization passes, IR codegen passes (some examples are here: https://github.com/llvm/llvm-project/blob/1d0244aed78114d5bd03ec4930d7687d6e587f99/llvm/include/llvm/CodeGen/MachinePassRegistry.def#L38-L51 and https://github.com/llvm/llvm-project/blob/1d0244aed78114d5bd03ec4930d7687d6e587f99/llvm/include/llvm/CodeGen/MachinePassRegistry.def#L106-L121) and MIR codegen passes. The JMC pass is an IR codegen passes. It runs within the codegen phase, but it transforms IR and it is tested using the opt tool. The llc option is for testing that the pass could be enabled using TargetOptions::JMCInstrument (clang uses this), the change in llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp and this option enables LTO+JMC with lld -mllvm -enable-jmc-instrument.

llvm/lib/CodeGen/JMCInstrumenter.cpp

146

I still worry a bit about the target-specific code here. Normally, IR passes don't have any target-specific knowledge, but ask classes such as TargetTransformInfo for target-specific details, or possibly take them as input to the pass. For example, see llvm/lib/Transforms/CFGuard/CFGuard.cpp

Understood. TargetTransformInfo is mostly for the "IR optimization passes". The JMC pass is "IR codegen passes", it is more similar to CodeGenPrepare pass than any "IR optimization passes". I think we could move the target-specific stuff into the TargetPassConfig & its derived classes, not in this patch, but the following ELF port one. WDYT?

148

yep, sounds good.

[ychen]

llvm/lib/CodeGen/JMCInstrumenter.cpp

146

I still worry a bit about the target-specific code here. Normally, IR passes don't have any target-specific knowledge, but ask classes such as TargetTransformInfo for target-specific details, or possibly take them as input to the pass. For example, see llvm/lib/Transforms/CFGuard/CFGuard.cpp

Understood. TargetTransformInfo is mostly for the "IR optimization passes". The JMC pass is "IR codegen passes", it is more similar to CodeGenPrepare pass than any "IR optimization passes". I think we could move the target-specific stuff into the TargetPassConfig & its derived classes, not in this patch, but the following ELF port one. WDYT?

Scratch that. I think this is more OS/platform-specific than target-specific. For X86, MSVC COFF and ELF are likely to have different symbol mangling and section naming preferences. And this information is pretty specific to JMC, like section name '.msvcjmc'. I think only X86 COFF has this weird mangling happen in LLVM codegen instead of the frontend. For non-x86 COFF and ELF, the handling is pretty much the same. So it may not be worth the effort of putting small pieces of OS/platform-specific information elsewhere?

[hans]

llvm/lib/CodeGen/CommandFlags.cpp

469

Thanks for the pointer, the IR codegen passes is something I'm not very familiar with.

Just looking at a few of the first ones you linked to, I see that they live under lib/Transforms/. And when I look in lib/CodeGen/ the vast majority of those work on MachineFunctions -- but not all. So I'm not really sure how we decide what should go where?

I think the best way is to look for a similar pass and see how that works. Maybe llvm/lib/Transforms/CFGuard/CFGuard.cpp could be a good example, since it's also inserting Windows-specific instrumentation at the IR level, similar to this pass.

llvm/lib/CodeGen/JMCInstrumenter.cpp

61

nit: this could be

const char CheckFunctionName[] = "..."

159

Having both Flag and TheFlag might be confusing. Could we rely on the DenseMap default-constructing values on lookup and do:

Constant *&Flag = SavedFlags[SP];
if (!Flag) {
  ...
  Flag = ...
}

[ychen]

• Address feeback

llvm/lib/CodeGen/CommandFlags.cpp

469

Looking into the CFGuard passes, I think they are all "IR codegen passes". I have no idea why they need to stay in lib/Transform (and in their own library LLVMCFGuard) instead of in lib/CodeGen. I would argue that they should probably be in lib/CodeGen instead. Hi @rnk , any idea about this?

llvm/lib/CodeGen/JMCInstrumenter.cpp

159

yep, this is better. Thanks.

[rnk]

llvm/lib/CodeGen/JMCInstrumenter.cpp

146

I think the existing PGO passes do a variety of target-specific things, and they live in lib/Transforms/Instrumentation. For example, they pick different section names for ELF and COFF.

This seems like the function entry/exit instrumentation, and I wonder if it should be added as part of the CodeGenPassBuilder.h list of passes.

[ychen]

• Remove a file that is included by accident.

[ychen]

llvm/lib/CodeGen/CommandFlags.cpp

469

Any objection if I keep the JMC pass in CodeGen and move CFGuard pass to CodeGen in a separate patch?

llvm/lib/CodeGen/JMCInstrumenter.cpp

146

> This seems like the function entry/exit instrumentation, and I wonder if it should be added as part of the CodeGenPassBuilder.h list of passes.

Yeah, it should. CodeGenPassBuilder.h is already lagging behind TargetPassConfig by far. I could take care of it when making CodeGenPassBuilder.h have parity with TargetPassConfig in terms of all lit tests.

[hans]

[hans]

It seems Phabricator ate my comment, but I meant to say:

My understanding is still that IR passes generally live in Transforms/ and that CodeGen/ deals with lower levels such as MachineInstrs, SelectionDAG, etc. with CodegenPrepare as the big exception.

Thinking about it another way, what about this pass makes it a "codegen IR" pass as opposed to all the other passes that add instrumentation to the IR and live in Transforms/Instrumentation/ ?

[ychen]

In D118428#3292918, @hans wrote:

It seems Phabricator ate my comment, but I meant to say:

My understanding is still that IR passes generally live in Transforms/ and that CodeGen/ deals with lower levels such as MachineInstrs, SelectionDAG, etc. with CodegenPrepare as the big exception.

Thinking about it another way, what about this pass makes it a "codegen IR" pass as opposed to all the other passes that add instrumentation to the IR and live in Transforms/Instrumentation/ ?

The passes in lib/Transforms/Instrumentation runs with EmitAssemblyHelper::RunOptimizationPipeline. JMC pass runs with EmitAssemblyHelper::RunCodegenPipeline.

[rnk]

In D118428#3294411, @ychen wrote:

The passes in lib/Transforms/Instrumentation runs with EmitAssemblyHelper::RunOptimizationPipeline. JMC pass runs with EmitAssemblyHelper::RunCodegenPipeline.

Sure, but that's a choice. Most of the instrumentation passes (ASan) are also designed to run late to avoid interfering with middle end optimization. Is there a specific reason that JMC has to be a codegen pass? Maybe you've already mentioned it, apologies if so.

As for whether this should be addressed in a follow-up, I think it's best to make sure we have the right library structure first, and then iterate on the implementation.

[ychen]

In D118428#3294880, @rnk wrote:

In D118428#3294411, @ychen wrote:

The passes in lib/Transforms/Instrumentation runs with EmitAssemblyHelper::RunOptimizationPipeline. JMC pass runs with EmitAssemblyHelper::RunCodegenPipeline.

Sure, but that's a choice. Most of the instrumentation passes (ASan) are also designed to run late to avoid interfering with middle end optimization. Is there a specific reason that JMC has to be a codegen pass? Maybe you've already mentioned it, apologies if so.

The instrumentation is per-function, ideally for each function that has debuginfo and ends up in the executable. So I want it to happen the last in the IR codegen pipeline (target could arrange additional IR passes, they may duplicate functions or anything). Making it codegen pass also makes it LTO-friendly, otherwise, I need to make sure the pass runs once. The JMC pass could be a machine-independent MIR pass too, but I think there is not much benefit for that.

[rnk]

In D118428#3294935, @ychen wrote:

The instrumentation is per-function, ideally for each function that has debuginfo and ends up in the executable. So I want it to happen the last in the IR codegen pipeline (target could arrange additional IR passes, they may duplicate functions or anything). Making it codegen pass also makes it LTO-friendly, otherwise, I need to make sure the pass runs once. The JMC pass could be a machine-independent MIR pass too, but I think there is not much benefit for that.

I would argue that function passes shouldn't do function duplication, but being LTO friendly is a pretty good reason to want to do instrumentation as part of the codegen pipeline. We have encountered problems with sanitizer passes running twice in LTO scenarios, and it's annoying to deal with.

So, I think that's a compelling reason to go with your current structure.

[hans]

llvm/lib/CodeGen/JMCInstrumenter.cpp

181

might as well get the Function* already here?

CheckFunction = cast<Function>(M.getOrInsertFunction(...).getCallee());

llvm/lib/CodeGen/TargetPassConfig.cpp

1096 ↗

(On Diff #405520)

could this be moved into addIRPasses()?

llvm/test/CodeGen/X86/jmc-instrument.ll

2 ↗

(On Diff #404805)

I still think it's unusual to have an llc test for an IR pass. Are there any other examples where we do something similar?

[ychen]

llvm/lib/CodeGen/JMCInstrumenter.cpp

181

sounds good.

llvm/lib/CodeGen/TargetPassConfig.cpp

1096 ↗

(On Diff #405520)

Yes, it could. CFGuardCheckPass is there for targets with COFF. I didn't put it there because I plan to make it work with ELF in the next step, putting it here is convenient. I don't feel strongly though.

llvm/test/CodeGen/X86/jmc-instrument.ll

2 ↗

(On Diff #404805)

yes, it is pretty rare. I wanted to test the CodeViewDebug.cpp change, however, the code path only triggers when the JMC pass is run. Using llc came to mind. I'm open to any alternative.

[ychen]

• address feedback

[hans]

llvm/lib/CodeGen/TargetPassConfig.cpp

1096 ↗

(On Diff #405520)

I think it would be better to move it to addIRPasses().

llvm/test/CodeGen/X86/jmc-instrument.ll

2 ↗

(On Diff #404805)

Oh, I see. But does the test check the right thing, then? I only see CHECKs for instructions, not debug info.

And isn't it enough to use IR with a global variable in the .msvcjmc section as input? I think the tighter the test, the better.

[ychen]

• Remove CodeViewDebug.cpp and the associated test. It was needed because the instrumented flag variables were scoped inside the associated method in the CodeView. The current patch puts them in the CU scope (which MSVC does). So the flag variable would never be decorated with qualified name.

[ychen]

llvm/test/CodeGen/X86/jmc-instrument.ll

2 ↗

(On Diff #404805)

It turns out that the CodeViewDebug.cpp change is not needed anymore. Delete this test too. Thanks for help spotting this!

[hans]

lgtm

[paulkirth]

Hi,

We have two failing test cases on Fuchsia's clang canary builder on Windows x64.

LLVM :: Instrumentation/JustMyCode/jmc-instrument-x86.ll
LLVM :: Instrumentation/JustMyCode/jmc-instrument.ll

First seen here: https://luci-milo.appspot.com/ui/p/fuchsia/builders/toolchain.ci/clang-windows-x64/b8822587673277278177/overview

These are JustMyCode tests, added in this patch, and it appears these tests may need to be adjusted.

You can find the full output in the linked builders, but here is a sample output from one of the tests. It seems to me like the lit file may just need to be adjusted slightly?

Script:
--
: 'RUN: at line 1';   c:\b\s\w\ir\x\w\staging\llvm_build\bin\opt.exe -jmc-instrument -S < C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll | c:\b\s\w\ir\x\w\staging\llvm_build\bin\filecheck.exe C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll
--
Exit Code: 1

Command Output (stdout):
--
$ ":" "RUN: at line 1"
$ "c:\b\s\w\ir\x\w\staging\llvm_build\bin\opt.exe" "-jmc-instrument" "-S"
$ "c:\b\s\w\ir\x\w\staging\llvm_build\bin\filecheck.exe" "C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll"
# command stderr:
C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll:5:10: error: CHECK: expected string not found in input
; CHECK: @"_A85D9D03_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0
         ^
<stdin>:6:34: note: scanning from here
$_JustMyCode_Default = comdat any
                                 ^
<stdin>:8:1: note: possible intended match here
@"_A8764FDD_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0
^

Input file: <stdin>
Check file: C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll

-dump-input=help explains the following input dump.

Input was:
<<<<<<
           1: ; ModuleID = '<stdin>' 
           2: source_filename = "<stdin>" 
           3: target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32-a:0:32-S32" 
           4: target triple = "i386-pc-windows-msvc" 
           5:  
           6: $_JustMyCode_Default = comdat any 
check:5'0                                      X error: no match found
           7:  
check:5'0     ~
           8: @"_A8764FDD_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
check:5'1     ?                                                                                           possible intended match
           9: @llvm.used = appending global [1 x i8*] [i8* bitcast (void (i8*)* @_JustMyCode_Default to i8*)], section "llvm.metadata" 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          10:  
check:5'0     ~
          11: define void @w1() #0 !dbg !10 { 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          12:  call x86_fastcallcc void @__CheckForDebuggerJustMyCode(i8* inreg noundef @"_A8764FDD_x@c") 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          13:  ret void 
check:5'0     ~~~~~~~~~~
           .
           .
           .
>>>>>>

error: command failed with exit status: 1

--

If fixing the test will take a long time, can you revert until one is ready?

[ychen]

In D118428#3312440, @paulkirth wrote:

Hi,

We have two failing test cases on Fuchsia's clang canary builder on Windows x64.

LLVM :: Instrumentation/JustMyCode/jmc-instrument-x86.ll
LLVM :: Instrumentation/JustMyCode/jmc-instrument.ll

First seen here: https://luci-milo.appspot.com/ui/p/fuchsia/builders/toolchain.ci/clang-windows-x64/b8822587673277278177/overview

These are JustMyCode tests, added in this patch, and it appears these tests may need to be adjusted.

You can find the full output in the linked builders, but here is a sample output from one of the tests. It seems to me like the lit file may just need to be adjusted slightly?

Script:
--
: 'RUN: at line 1';   c:\b\s\w\ir\x\w\staging\llvm_build\bin\opt.exe -jmc-instrument -S < C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll | c:\b\s\w\ir\x\w\staging\llvm_build\bin\filecheck.exe C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll
--
Exit Code: 1

Command Output (stdout):
--
$ ":" "RUN: at line 1"
$ "c:\b\s\w\ir\x\w\staging\llvm_build\bin\opt.exe" "-jmc-instrument" "-S"
$ "c:\b\s\w\ir\x\w\staging\llvm_build\bin\filecheck.exe" "C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll"
# command stderr:
C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll:5:10: error: CHECK: expected string not found in input
; CHECK: @"_A85D9D03_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0
         ^
<stdin>:6:34: note: scanning from here
$_JustMyCode_Default = comdat any
                                 ^
<stdin>:8:1: note: possible intended match here
@"_A8764FDD_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0
^

Input file: <stdin>
Check file: C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll

-dump-input=help explains the following input dump.

Input was:
<<<<<<
           1: ; ModuleID = '<stdin>' 
           2: source_filename = "<stdin>" 
           3: target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32-a:0:32-S32" 
           4: target triple = "i386-pc-windows-msvc" 
           5:  
           6: $_JustMyCode_Default = comdat any 
check:5'0                                      X error: no match found
           7:  
check:5'0     ~
           8: @"_A8764FDD_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
check:5'1     ?                                                                                           possible intended match
           9: @llvm.used = appending global [1 x i8*] [i8* bitcast (void (i8*)* @_JustMyCode_Default to i8*)], section "llvm.metadata" 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          10:  
check:5'0     ~
          11: define void @w1() #0 !dbg !10 { 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          12:  call x86_fastcallcc void @__CheckForDebuggerJustMyCode(i8* inreg noundef @"_A8764FDD_x@c") 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          13:  ret void 
check:5'0     ~~~~~~~~~~
           .
           .
           .
>>>>>>

error: command failed with exit status: 1

--

If fixing the test will take a long time, can you revert until one is ready?

Reverted in b380a31de084a540cfa38. Thanks. I'll take a look.

[ychen]

In D118428#3312621, @ychen wrote:

In D118428#3312440, @paulkirth wrote:

Hi,

We have two failing test cases on Fuchsia's clang canary builder on Windows x64.

LLVM :: Instrumentation/JustMyCode/jmc-instrument-x86.ll
LLVM :: Instrumentation/JustMyCode/jmc-instrument.ll

First seen here: https://luci-milo.appspot.com/ui/p/fuchsia/builders/toolchain.ci/clang-windows-x64/b8822587673277278177/overview

These are JustMyCode tests, added in this patch, and it appears these tests may need to be adjusted.

You can find the full output in the linked builders, but here is a sample output from one of the tests. It seems to me like the lit file may just need to be adjusted slightly?

Script:
--
: 'RUN: at line 1';   c:\b\s\w\ir\x\w\staging\llvm_build\bin\opt.exe -jmc-instrument -S < C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll | c:\b\s\w\ir\x\w\staging\llvm_build\bin\filecheck.exe C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll
--
Exit Code: 1

Command Output (stdout):
--
$ ":" "RUN: at line 1"
$ "c:\b\s\w\ir\x\w\staging\llvm_build\bin\opt.exe" "-jmc-instrument" "-S"
$ "c:\b\s\w\ir\x\w\staging\llvm_build\bin\filecheck.exe" "C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll"
# command stderr:
C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll:5:10: error: CHECK: expected string not found in input
; CHECK: @"_A85D9D03_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0
         ^
<stdin>:6:34: note: scanning from here
$_JustMyCode_Default = comdat any
                                 ^
<stdin>:8:1: note: possible intended match here
@"_A8764FDD_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0
^

Input file: <stdin>
Check file: C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\Instrumentation\JustMyCode\jmc-instrument-x86.ll

-dump-input=help explains the following input dump.

Input was:
<<<<<<
           1: ; ModuleID = '<stdin>' 
           2: source_filename = "<stdin>" 
           3: target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32-a:0:32-S32" 
           4: target triple = "i386-pc-windows-msvc" 
           5:  
           6: $_JustMyCode_Default = comdat any 
check:5'0                                      X error: no match found
           7:  
check:5'0     ~
           8: @"_A8764FDD_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
check:5'1     ?                                                                                           possible intended match
           9: @llvm.used = appending global [1 x i8*] [i8* bitcast (void (i8*)* @_JustMyCode_Default to i8*)], section "llvm.metadata" 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          10:  
check:5'0     ~
          11: define void @w1() #0 !dbg !10 { 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          12:  call x86_fastcallcc void @__CheckForDebuggerJustMyCode(i8* inreg noundef @"_A8764FDD_x@c") 
check:5'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          13:  ret void 
check:5'0     ~~~~~~~~~~
           .
           .
           .
>>>>>>

error: command failed with exit status: 1

--

If fixing the test will take a long time, can you revert until one is ready?

Reverted in b380a31de084a540cfa38. Thanks. I'll take a look.

Relanded in f927021410691bc261

clang/docs/ReleaseNotes.rst

 Attribute Changes in Clang
 --------------------------
 
 - Added support for parameter pack expansion in `clang::annotate`.
 
 Windows Support
 ---------------
 
+- Add support for MSVC-compatible ``/JMC``/``/JMC-`` flag in clang-cl (supports
+  X86/X64/ARM/ARM64). ``/JMC`` could only be used when ``/Zi`` or ``/Z7`` is
+  turned on. With this addition, clang-cl can be used in Visual Studio for the
+  JustMyCode feature. Note, you may need to manually add ``/JMC`` as additional
+  compile options in the Visual Studio since it currently assumes clang-cl does not support ``/JMC``.
+
 C Language Changes in Clang
 ---------------------------
 
 C++ Language Changes in Clang
 -----------------------------
 
 - ...
 

clang/include/clang/Basic/CodeGenOptions.def

 VALUE_CODEGENOPT(XRaySelectedFunctionGroup, 32, 0)
 
 VALUE_CODEGENOPT(PatchableFunctionEntryCount , 32, 0) ///< Number of NOPs at function entry
 VALUE_CODEGENOPT(PatchableFunctionEntryOffset , 32, 0)
 
 CODEGENOPT(HotPatch, 1, 0) ///< Supports the Microsoft /HOTPATCH flag and
                            ///< generates a 'patchable-function' attribute.
 
+CODEGENOPT(JMCInstrument, 1, 0) ///< Set when -fjmc is enabled.
 CODEGENOPT(InstrumentForProfiling , 1, 0) ///< Set when -pg is enabled.
 CODEGENOPT(CallFEntry , 1, 0) ///< Set when -mfentry is enabled.
 CODEGENOPT(MNopMCount , 1, 0) ///< Set when -mnop-mcount is enabled.
 CODEGENOPT(RecordMCount , 1, 0) ///< Set when -mrecord-mcount is enabled.
 CODEGENOPT(PackedStack , 1, 0) ///< Set when -mpacked-stack is enabled.
 CODEGENOPT(LessPreciseFPMAD  , 1, 0) ///< Enable less precise MAD instructions to
                                      ///< be generated.
 CODEGENOPT(PrepareForLTO     , 1, 0) ///< Set when -flto is enabled on the

clang/include/clang/Basic/DiagnosticDriverKinds.td

def err_drv_ssp_missing_offset_argument : Error<
   "'%0' is used without '-mstack-protector-guard-offset', and there is no default">;
 
 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">,
+  InGroup<OptionIgnored>;
 }

clang/include/clang/Driver/Options.td

defm elide_constructors : BoolFOption<"elide-constructors",
   LangOpts<"ElideConstructors">, DefaultTrue,
   NegFlag<SetFalse, [CC1Option], "Disable C++ copy constructor elision">,
   PosFlag<SetTrue>>;
 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">>;
 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">,
HelpText<"Enable Control Flow Guard with /guard:cf, or only the table with /guard:cf,nochecks. "
            "Enable EH Continuation Guard with /guard:ehcont">;
 def _SLASH_GX : CLFlag<"GX">,
   HelpText<"Deprecated; use /EHsc">;
 def _SLASH_GX_ : CLFlag<"GX-">,
   HelpText<"Deprecated (like not passing /EH)">;
 def _SLASH_imsvc : CLJoinedOrSeparate<"imsvc">,
   HelpText<"Add <dir> to system include search path, as if in %INCLUDE%">,
   MetaVarName<"<dir>">;
+def _SLASH_JMC : CLFlag<"JMC">,
+  HelpText<"Enable just-my-code debugging">;
+def _SLASH_JMC_ : CLFlag<"JMC-">,
+  HelpText<"Disable just-my-code debugging (default)">;
 def _SLASH_LD : CLFlag<"LD">, HelpText<"Create DLL">;
 def _SLASH_LDd : CLFlag<"LDd">, HelpText<"Create debug DLL">;
 def _SLASH_link : CLRemainingArgsJoined<"link">,
   HelpText<"Forward options to the linker">, MetaVarName<"<options>">;
 def _SLASH_MD : Option<["/", "-"], "MD", KIND_FLAG>, Group<_SLASH_M_Group>,
   Flags<[CLOption, NoXarchOption]>, HelpText<"Use DLL run-time">;
 def _SLASH_MDd : Option<["/", "-"], "MDd", KIND_FLAG>, Group<_SLASH_M_Group>,
   Flags<[CLOption, NoXarchOption]>, HelpText<"Use DLL debug run-time">;

 def _SLASH_bigobj : CLIgnoredFlag<"bigobj">;
 def _SLASH_cgthreads : CLIgnoredJoined<"cgthreads">;
 def _SLASH_d2FastFail : CLIgnoredFlag<"d2FastFail">;
 def _SLASH_d2Zi_PLUS : CLIgnoredFlag<"d2Zi+">;
 def _SLASH_errorReport : CLIgnoredJoined<"errorReport">;
 def _SLASH_FC : CLIgnoredFlag<"FC">;
 def _SLASH_Fd : CLIgnoredJoined<"Fd">;
 def _SLASH_FS : CLIgnoredFlag<"FS">;
-def _SLASH_JMC : CLIgnoredFlag<"JMC">;
 def _SLASH_kernel_ : CLIgnoredFlag<"kernel-">;
 def _SLASH_nologo : CLIgnoredFlag<"nologo">;
 def _SLASH_RTC : CLIgnoredJoined<"RTC">;
 def _SLASH_sdl : CLIgnoredFlag<"sdl">;
 def _SLASH_sdl_ : CLIgnoredFlag<"sdl-">;
 def _SLASH_utf8 : CLIgnoredFlag<"utf-8">,
   HelpText<"Set source and runtime encoding to UTF-8 (default)">;
 def _SLASH_w : CLIgnoredJoined<"w">;

clang/lib/CodeGen/BackendUtil.cpp

static bool initTargetOptions(DiagnosticsEngine &Diags,
   Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;
   Options.StackUsageOutput = CodeGenOpts.StackUsageOutput;
   Options.EmitAddrsig = CodeGenOpts.Addrsig;
   Options.ForceDwarfFrameSection = CodeGenOpts.ForceDwarfFrameSection;
   Options.EmitCallSiteInfo = CodeGenOpts.EmitCallSiteInfo;
   Options.EnableAIXExtendedAltivecABI = CodeGenOpts.EnableAIXExtendedAltivecABI;
   Options.XRayOmitFunctionIndex = CodeGenOpts.XRayOmitFunctionIndex;
   Options.LoopAlignment = CodeGenOpts.LoopAlignment;
+  Options.DebugStrictDwarf = CodeGenOpts.DebugStrictDwarf;
+  Options.ObjectFilenameForDebug = CodeGenOpts.ObjectFilenameForDebug;
+  Options.Hotpatch = CodeGenOpts.HotPatch;
+  Options.JMCInstrument = CodeGenOpts.JMCInstrument;
 
   switch (CodeGenOpts.getSwiftAsyncFramePointer()) {
   case CodeGenOptions::SwiftAsyncFramePointerKind::Auto:
     Options.SwiftAsyncFramePointer =
         SwiftAsyncFramePointerMode::DeploymentBased;
     break;
 
   case CodeGenOptions::SwiftAsyncFramePointerKind::Always:
for (const auto &Entry : HSOpts.UserEntries)
     if (!Entry.IsFramework &&
         (Entry.Group == frontend::IncludeDirGroup::Quoted ||
          Entry.Group == frontend::IncludeDirGroup::Angled ||
          Entry.Group == frontend::IncludeDirGroup::System))
       Options.MCOptions.IASSearchPaths.push_back(
           Entry.IgnoreSysRoot ? Entry.Path : HSOpts.Sysroot + Entry.Path);
   Options.MCOptions.Argv0 = CodeGenOpts.Argv0;
   Options.MCOptions.CommandLineArgs = CodeGenOpts.CommandLineArgs;
-  Options.DebugStrictDwarf = CodeGenOpts.DebugStrictDwarf;
-  Options.ObjectFilenameForDebug = CodeGenOpts.ObjectFilenameForDebug;
-  Options.Hotpatch = CodeGenOpts.HotPatch;
 
   return true;
 }
 
 static Optional<GCOVOptions> getGCOVOptions(const CodeGenOptions &CodeGenOpts,
                                             const LangOptions &LangOpts) {
   if (!CodeGenOpts.EmitGcovArcs && !CodeGenOpts.EmitGcovNotes)
     return None;

clang/lib/Driver/ToolChains/Clang.cpp

if (DebugInfoArg->getOption().matches(options::OPT__SLASH_Z7))
       *DebugInfoKind = codegenoptions::DebugInfoConstructor;
     else
       *DebugInfoKind = codegenoptions::DebugLineTablesOnly;
   } else {
     *EmitCodeView = false;
   }
 
   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);
+  }
+
   EHFlags EH = parseClangCLEHFlags(D, Args);
   if (!isNVPTX && (EH.Synch || EH.Asynch)) {
     if (types::isCXX(InputType))
       CmdArgs.push_back("-fcxx-exceptions");
     CmdArgs.push_back("-fexceptions");
   }
   if (types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
     CmdArgs.push_back("-fexternc-nounwind");

clang/test/Driver/cl-options.c

 // RUN:     /GS \
 // RUN:     /GT \
 // RUN:     /GX \
 // RUN:     /Gv \
 // RUN:     /Gz \
 // RUN:     /GZ \
 // RUN:     /H \
 // RUN:     /homeparams \
-// RUN:     /JMC \
 // RUN:     /kernel \
 // RUN:     /LN \
 // RUN:     /MP \
 // RUN:     /o foo.obj \
 // RUN:     /ofoo.obj \
 // RUN:     /openmp \
 // RUN:     /openmp:experimental \
 // RUN:     /Qfast_transcendentals \

 // FAKEDIR: "-internal-isystem" "/foo{{/|\\\\}}Include{{/|\\\\}}10.0.12345.0{{/|\\\\}}um"
 // FAKEDIR: "-internal-isystem" "/foo{{/|\\\\}}Include{{/|\\\\}}10.0.12345.0{{/|\\\\}}winrt"
 // FAKEDIR: "-libpath:/fake{{/|\\\\}}lib{{/|\\\\}}
 // FAKEDIR: "-libpath:/fake{{/|\\\\}}atlmfc{{/|\\\\}}lib{{/|\\\\}}
 // FAKEDIR: "-libpath:/foo{{/|\\\\}}Lib{{/|\\\\}}10.0.12345.0{{/|\\\\}}ucrt
 // 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
+
+// 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) { }

llvm/include/llvm/CodeGen/CommandFlags.h

 bool getForceDwarfFrameSection();
 
 bool getXRayOmitFunctionIndex();
 
 bool getDebugStrictDwarf();
 
 unsigned getAlignLoops();
 
+bool getJMCInstrument();
+
 /// Create this object with static storage to register codegen-related command
 /// line options.
 struct RegisterCodeGenFlags {
   RegisterCodeGenFlags();
 };
 
 llvm::BasicBlockSection getBBSectionsMode(llvm::TargetOptions &Options);
 

llvm/include/llvm/CodeGen/Passes.h

namespace llvm {
 
   /// The pass transforms amx intrinsics to scalar operation if the function has
   /// optnone attribute or it is O0.
   FunctionPass *createX86LowerAMXIntrinsicsPass();
 
   /// When learning an eviction policy, extract score(reward) information,
   /// otherwise this does nothing
   FunctionPass *createRegAllocScoringPass();
+
+  /// JMC instrument pass.
+  ModulePass *createJMCInstrumenterPass();
 } // End llvm namespace
 
 #endif

llvm/include/llvm/InitializePasses.h

 void initializeInstrProfilingLegacyPassPass(PassRegistry&);
 void initializeInstrOrderFileLegacyPassPass(PassRegistry&);
 void initializeInstructionCombiningPassPass(PassRegistry&);
 void initializeInstructionSelectPass(PassRegistry&);
 void initializeInterleavedAccessPass(PassRegistry&);
 void initializeInterleavedLoadCombinePass(PassRegistry &);
 void initializeInternalizeLegacyPassPass(PassRegistry&);
 void initializeIntervalPartitionPass(PassRegistry&);
+void initializeJMCInstrumenterPass(PassRegistry&);
 void initializeJumpThreadingPass(PassRegistry&);
 void initializeLCSSAVerificationPassPass(PassRegistry&);
 void initializeLCSSAWrapperPassPass(PassRegistry&);
 void initializeLazyBlockFrequencyInfoPassPass(PassRegistry&);
 void initializeLazyBranchProbabilityInfoPassPass(PassRegistry&);
 void initializeLazyMachineBlockFrequencyInfoPassPass(PassRegistry&);
 void initializeLazyValueInfoPrinterPass(PassRegistry&);
 void initializeLazyValueInfoWrapperPassPass(PassRegistry&);

llvm/include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createGuardWideningPass();
       (void) llvm::createLoopGuardWideningPass();
       (void) llvm::createIPSCCPPass();
       (void) llvm::createInductiveRangeCheckEliminationPass();
       (void) llvm::createIndVarSimplifyPass();
       (void) llvm::createInstSimplifyLegacyPass();
       (void) llvm::createInstructionCombiningPass();
       (void) llvm::createInternalizePass();
+      (void) llvm::createJMCInstrumenterPass();
       (void) llvm::createLCSSAPass();
       (void) llvm::createLegacyDivergenceAnalysisPass();
       (void) llvm::createLICMPass();
       (void) llvm::createLoopSinkPass();
       (void) llvm::createLazyValueInfoPass();
       (void) llvm::createLoopExtractorPass();
       (void) llvm::createLoopInterchangePass();
       (void) llvm::createLoopFlattenPass();

llvm/include/llvm/Target/TargetOptions.h

TargetOptions()
           TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0),
           EmulatedTLS(false), ExplicitEmulatedTLS(false), EnableIPRA(false),
           EmitStackSizeSection(false), EnableMachineOutliner(false),
           EnableMachineFunctionSplitter(false), SupportsDefaultOutlining(false),
           EmitAddrsig(false), EmitCallSiteInfo(false),
           SupportsDebugEntryValues(false), EnableDebugEntryValues(false),
           ValueTrackingVariableLocations(false), ForceDwarfFrameSection(false),
           XRayOmitFunctionIndex(false), DebugStrictDwarf(false),
-          Hotpatch(false), PPCGenScalarMASSEntries(false),
+          Hotpatch(false), PPCGenScalarMASSEntries(false), JMCInstrument(false),
           FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {}
 
     /// DisableFramePointerElim - This returns true if frame pointer elimination
     /// optimization should be disabled for the given machine function.
     bool DisableFramePointerElim(const MachineFunction &MF) const;
 
     /// If greater than 0, override the default value of
     /// MCAsmInfo::BinutilsVersion.
public:
     unsigned DebugStrictDwarf : 1;
 
     /// Emit the hotpatch flag in CodeView debug.
     unsigned Hotpatch : 1;
 
     /// Enables scalar MASS conversions
     unsigned PPCGenScalarMASSEntries : 1;
 
+    /// Enable JustMyCode instrumentation.
+    unsigned JMCInstrument : 1;
+
     /// Name of the stack usage file (i.e., .su file) if user passes
     /// -fstack-usage. If empty, it can be implied that -fstack-usage is not
     /// passed on the command line.
     std::string StackUsageOutput;
 
     /// If greater than 0, override TargetLoweringBase::PrefLoopAlignment.
     unsigned LoopAlignment = 0;
 

llvm/lib/CodeGen/CMakeLists.txt

add_llvm_component_library(LLVMCodeGen
   IfConversion.cpp
   ImplicitNullChecks.cpp
   IndirectBrExpandPass.cpp
   InlineSpiller.cpp
   InterferenceCache.cpp
   InterleavedAccessPass.cpp
   InterleavedLoadCombinePass.cpp
   IntrinsicLowering.cpp
+  JMCInstrumenter.cpp
   LatencyPriorityQueue.cpp
   LazyMachineBlockFrequencyInfo.cpp
   LexicalScopes.cpp
   LiveDebugVariables.cpp
   LiveIntervals.cpp
   LiveInterval.cpp
   LiveIntervalUnion.cpp
   LivePhysRegs.cpp

llvm/lib/CodeGen/CodeGen.cpp

void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeGCMachineCodeAnalysisPass(Registry);
   initializeGCModuleInfoPass(Registry);
   initializeHardwareLoopsPass(Registry);
   initializeIfConverterPass(Registry);
   initializeImplicitNullChecksPass(Registry);
   initializeIndirectBrExpandPassPass(Registry);
   initializeInterleavedLoadCombinePass(Registry);
   initializeInterleavedAccessPass(Registry);
+  initializeJMCInstrumenterPass(Registry);
   initializeLiveDebugValuesPass(Registry);
   initializeLiveDebugVariablesPass(Registry);
   initializeLiveIntervalsPass(Registry);
   initializeLiveRangeShrinkPass(Registry);
   initializeLiveStacksPass(Registry);
   initializeLiveVariablesPass(Registry);
   initializeLocalStackSlotPassPass(Registry);
   initializeLowerIntrinsicsPass(Registry);

llvm/lib/CodeGen/CommandFlags.cpp

 CGOPT(bool, EnableAddrsig)
 CGOPT(bool, EmitCallSiteInfo)
 CGOPT(bool, EnableMachineFunctionSplitter)
 CGOPT(bool, EnableDebugEntryValues)
 CGOPT(bool, ForceDwarfFrameSection)
 CGOPT(bool, XRayOmitFunctionIndex)
 CGOPT(bool, DebugStrictDwarf)
 CGOPT(unsigned, AlignLoops)
+CGOPT(bool, JMCInstrument)
 
 codegen::RegisterCodeGenFlags::RegisterCodeGenFlags() {
 #define CGBINDOPT(NAME)                                                        \
   do {                                                                         \
     NAME##View = std::addressof(NAME);                                         \
   } while (0)
 
   static cl::opt<std::string> MArch(
#define CGBINDOPT(NAME)                                                        \
   static cl::opt<bool> DebugStrictDwarf(
       "strict-dwarf", cl::desc("use strict dwarf"), cl::init(false));
   CGBINDOPT(DebugStrictDwarf);
 
   static cl::opt<unsigned> AlignLoops("align-loops",
                                       cl::desc("Default alignment for loops"));
   CGBINDOPT(AlignLoops);
 
+  static cl::opt<bool> JMCInstrument(
+      "enable-jmc-instrument",
+      cl::desc("Instrument functions with a call to __CheckForDebuggerJustMyCode"),
+      cl::init(false));
+  CGBINDOPT(JMCInstrument);
+
 #undef CGBINDOPT
 
   mc::RegisterMCTargetOptionsFlags();
 }
 
 llvm::BasicBlockSection
 codegen::getBBSectionsMode(llvm::TargetOptions &Options) {
   if (getBBSections() == "all")
codegen::InitTargetOptionsFromCodeGenFlags(const Triple &TheTriple) {
   Options.EnableMachineFunctionSplitter = getEnableMachineFunctionSplitter();
   Options.EmitAddrsig = getEnableAddrsig();
   Options.EmitCallSiteInfo = getEmitCallSiteInfo();
   Options.EnableDebugEntryValues = getEnableDebugEntryValues();
   Options.ForceDwarfFrameSection = getForceDwarfFrameSection();
   Options.XRayOmitFunctionIndex = getXRayOmitFunctionIndex();
   Options.DebugStrictDwarf = getDebugStrictDwarf();
   Options.LoopAlignment = getAlignLoops();
+  Options.JMCInstrument = getJMCInstrument();
 
   Options.MCOptions = mc::InitMCTargetOptionsFromFlags();
 
   Options.ThreadModel = getThreadModel();
   Options.EABIVersion = getEABIVersion();
   Options.DebuggerTuning = getDebuggerTuningOpt();
   Options.SwiftAsyncFramePointer = getSwiftAsyncFramePointer();
   return Options;

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
+//
+//===----------------------------------------------------------------------===//
+
+#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"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
+#include "llvm/InitializePasses.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/DJB.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Transforms/Utils/ModuleUtils.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "jmc-instrument"
+
+namespace {
+struct JMCInstrumenter : public ModulePass {
+  static char ID;
+  JMCInstrumenter() : ModulePass(ID) {
+    initializeJMCInstrumenterPass(*PassRegistry::getPassRegistry());
+  }
+  bool runOnModule(Module &M) override;
+};
+char JMCInstrumenter::ID = 0;
+} // namespace
+
+INITIALIZE_PASS(
+    JMCInstrumenter, DEBUG_TYPE,
+    "Instrument function entry with call to __CheckForDebuggerJustMyCode",
+    false, false)
+
+ModulePass *llvm::createJMCInstrumenterPass() { return new JMCInstrumenter(); }
+
+namespace {
+const char CheckFunctionName[] = "__CheckForDebuggerJustMyCode";
+
+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.
+
+  std::string Suffix;
+  for (auto C : sys::path::filename(FilePath))
+    Suffix.push_back(C == '.' ? '@' : C);
+
+  sys::path::remove_filename(FilePath);
+  return (UseX86FastCall ? "_" : "__") +
+         utohexstr(djbHash(FilePath), /*LowerCase=*/false,
+                   /*Width=*/8) +
+         "_" + Suffix;
+}
+
+void attachDebugInfo(GlobalVariable &GV, DISubprogram &SP) {
+  Module &M = *GV.getParent();
+  DICompileUnit *CU = SP.getUnit();
+  assert(CU);
+  DIBuilder DB(M, false, CU);
+
+  auto *DType =
+      DB.createBasicType("unsigned char", 8, dwarf::DW_ATE_unsigned_char,
+                         llvm::DINode::FlagArtificial);
+
+  auto *DGVE = DB.createGlobalVariableExpression(
+      CU, GV.getName(), /*LinkageName=*/StringRef(), SP.getFile(),
+      /*LineNo=*/0, DType, /*IsLocalToUnit=*/true, /*IsDefined=*/true);
+  GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
+  DB.finalize();
+}
+
+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) {
+  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);
+}
+} // 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;
+
+  Function *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->setAlignment(Align(1));
+        GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
+        attachDebugInfo(*GV, *SP);
+        return GV;
+      });
+    }
+
+    if (!CheckFunction) {
+      assert(!M.getFunction(CheckFunctionName) &&
+             "JMC instrument more than once?");
+      CheckFunction = cast<Function>(
+          M.getOrInsertFunction(CheckFunctionName, getCheckFunctionType(Ctx))
+              .getCallee());
+      CheckFunction->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
+      CheckFunction->addParamAttr(0, Attribute::NoUndef);
+      if (UseX86FastCall) {
+        CheckFunction->setCallingConv(CallingConv::X86_FastCall);
+        CheckFunction->addParamAttr(0, Attribute::InReg);
+      }
+    }
+    // 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());
+    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;
+}

llvm/lib/Target/AArch64/AArch64TargetMachine.cpp

if (TM->getOptLevel() == CodeGenOpt::Aggressive && EnableGEPOpt) {
     // Do loop invariant code motion in case part of the lowered result is
     // invariant.
     addPass(createLICMPass());
   }
 
   // Add Control Flow Guard checks.
   if (TM->getTargetTriple().isOSWindows())
     addPass(createCFGuardCheckPass());
+
+  if (TM->Options.JMCInstrument)
+    addPass(createJMCInstrumenterPass());
 }
 
 // Pass Pipeline Configuration
 bool AArch64PassConfig::addPreISel() {
   // Run promote constant before global merge, so that the promoted constants
   // get a chance to be merged
   if (TM->getOptLevel() != CodeGenOpt::None && EnablePromoteConstant)
     addPass(createAArch64PromoteConstantPass());

llvm/lib/Target/ARM/ARMTargetMachine.cpp

void ARMPassConfig::addIRPasses() {
 
   // Match interleaved memory accesses to ldN/stN intrinsics.
   if (TM->getOptLevel() != CodeGenOpt::None)
     addPass(createInterleavedAccessPass());
 
   // Add Control Flow Guard checks.
   if (TM->getTargetTriple().isOSWindows())
     addPass(createCFGuardCheckPass());
+
+  if (TM->Options.JMCInstrument)
+    addPass(createJMCInstrumenterPass());
 }
 
 void ARMPassConfig::addCodeGenPrepare() {
   if (getOptLevel() != CodeGenOpt::None)
     addPass(createTypePromotionPass());
   TargetPassConfig::addCodeGenPrepare();
 }
 

llvm/lib/Target/X86/X86TargetMachine.cpp

void X86PassConfig::addIRPasses() {
   const Triple &TT = TM->getTargetTriple();
   if (TT.isOSWindows()) {
     if (TT.getArch() == Triple::x86_64) {
       addPass(createCFGuardDispatchPass());
     } else {
       addPass(createCFGuardCheckPass());
     }
   }
+
+  if (TM->Options.JMCInstrument)
+    addPass(createJMCInstrumenterPass());
 }
 
 bool X86PassConfig::addInstSelector() {
   // Install an instruction selector.
   addPass(createX86ISelDag(getX86TargetMachine(), getOptLevel()));
 
   // For ELF, cleanup any local-dynamic TLS accesses.
   if (TM->getTargetTriple().isOSBinFormatELF() &&

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

+; RUN: opt -jmc-instrument -S < %s | FileCheck %s
+
+; CHECK: $_JustMyCode_Default = comdat any
+
+; CHECK: @"_A85D9D03_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 @"_A85D9D03_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: !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+; CHECK: !1 = distinct !DIGlobalVariable(name: "_A85D9D03_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}
+; CHECK: !8 = !{!"clang"}
+; CHECK: !9 = !{!"/alternatename:__CheckForDebuggerJustMyCode=_JustMyCode_Default"}
+; CHECK: !10 = distinct !DISubprogram(name: "w1", scope: !3, file: !3, line: 1, type: !11, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !13)
+; CHECK: !11 = !DISubroutineType(types: !12)
+
+target datalayout = "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32-a:0:32-S32"
+target triple = "i386-pc-windows-msvc"
+
+define void @w1() #0 !dbg !10 {
+  ret void
+}
+
+attributes #0 = { "target-cpu"="pentium4" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!7, !8}
+!llvm.ident = !{!9}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "./b/./../b/x.c", directory: "C:\\\\a\\\\")
+!7 = !{i32 2, !"CodeView", i32 1}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{!"clang"}
+!10 = distinct !DISubprogram(name: "w1", scope: !1, file: !1, line: 1, type: !31, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !33)
+!31 = !DISubroutineType(types: !32)
+!32 = !{null}
+!33 = !{}

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

+; 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: @"__7DF23CF5_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0
+; CHECK: @"__A85D9D03_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 @"__7DF23CF5_x@c")
+; CHECK:   ret void
+; CHECK: }
+
+; CHECK: define void @l2() !dbg !17 {
+; 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 @"__A85D9D03_x@c")
+; CHECK:   ret void
+; CHECK: }
+
+; CHECK: define void @w2() !dbg !20 {
+; 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 @"__A85D9D03_x@c")
+; CHECK:   ret void
+; CHECK: }
+
+; CHECK: define void @w4() !dbg !24 {
+; 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:   ret void
+; CHECK: }
+
+; CHECK: !llvm.linker.options = !{!12}
+
+; CHECK: !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+; 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: "__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")
+
+; All use the same flag
+define void @l1() !dbg !10 {
+  ret void
+}
+define void @l2() !dbg !11 {
+  ret void
+}
+
+; All use the same flag
+define void @w1() !dbg !12 {
+  ret void
+}
+define void @w2() !dbg !13 {
+  ret void
+}
+define void @w3() !dbg !14 {
+  ret void
+}
+define void @w4() !dbg !15 {
+  ret void
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!7, !8}
+!llvm.ident = !{!9}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "a/x.c", directory: "/tmp")
+!2 = !DIFile(filename: "x.c", directory: "/tmp/a")
+!3 = !DIFile(filename: "./x.c", directory: "C:\\\\a\\\\b\\\\")
+!4 = !DIFile(filename: "./b\\x.c", directory: "C:\\\\a\\\\")
+!5 = !DIFile(filename: "./b/x.c", directory: "C:\\\\a\\\\")
+!6 = !DIFile(filename: "./b/./../b/x.c", directory: "C:\\\\a")
+!7 = !{i32 2, !"CodeView", i32 1}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{!"clang"}
+!10 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 1, type: !31, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !33)
+!11 = distinct !DISubprogram(name: "f", scope: !2, file: !2, line: 1, type: !31, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !33)
+!12 = distinct !DISubprogram(name: "f", scope: !3, file: !3, line: 1, type: !31, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !33)
+!13 = distinct !DISubprogram(name: "f", scope: !4, file: !4, line: 1, type: !31, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !33)
+!14 = distinct !DISubprogram(name: "f", scope: !5, file: !5, line: 1, type: !31, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !33)
+!15 = distinct !DISubprogram(name: "f", scope: !6, file: !6, line: 1, type: !31, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !33)
+!31 = !DISubroutineType(types: !32)
+!32 = !{null}
+!33 = !{}

llvm/tools/opt/opt.cpp

std::vector<StringRef> PassNameExact = {
       "atomic-expand",        "expandvp",
       "hardware-loops",       "type-promotion",
       "mve-tail-predication", "interleaved-access",
       "global-merge",         "pre-isel-intrinsic-lowering",
       "expand-reductions",    "indirectbr-expand",
       "generic-to-nvvm",      "expandmemcmp",
       "loop-reduce",          "lower-amx-type",
       "pre-amx-config",       "lower-amx-intrinsics",
-      "polyhedral-info",      "replace-with-veclib"};
+      "polyhedral-info",      "replace-with-veclib",
+      "jmc-instrument"};
   for (const auto &P : PassNamePrefix)
     if (Pass.startswith(P))
       return true;
   for (const auto &P : PassNameContain)
     if (Pass.contains(P))
       return true;
   return llvm::is_contained(PassNameExact, Pass);
 }
int main(int argc, char **argv) {
   initializeUnreachableBlockElimLegacyPassPass(Registry);
   initializeExpandReductionsPass(Registry);
   initializeExpandVectorPredicationPass(Registry);
   initializeWasmEHPreparePass(Registry);
   initializeWriteBitcodePassPass(Registry);
   initializeHardwareLoopsPass(Registry);
   initializeTypePromotionPass(Registry);
   initializeReplaceWithVeclibLegacyPass(Registry);
+  initializeJMCInstrumenterPass(Registry);
 
 #ifdef BUILD_EXAMPLES
   initializeExampleIRTransforms(Registry);
 #endif
 
   cl::ParseCommandLineOptions(argc, argv,
     "llvm .bc -> .bc modular optimizer and analysis printer\n");