1 //===- JMCInstrumenter.cpp - JMC Instrumentation --------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // JMCInstrumenter pass:
10 // - instrument each function with a call to __CheckForDebuggerJustMyCode. The
11 //   sole argument should be defined in .msvcjmc. Each flag is 1 byte initilized
12 //   to 1.
13 // - create the dummy COMDAT function __JustMyCode_Default to prevent linking
14 //   error if __CheckForDebuggerJustMyCode is not available.
15 // - For MSVC:
16 //   add "/alternatename:__CheckForDebuggerJustMyCode=__JustMyCode_Default" to
17 //   "llvm.linker.options"
18 //   For ELF:
19 //   Rename __JustMyCode_Default to __CheckForDebuggerJustMyCode and mark it as
20 //   weak symbol.
21 //===----------------------------------------------------------------------===//
22 
23 #include "llvm/ADT/SmallString.h"
24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/CodeGen/Passes.h"
26 #include "llvm/IR/DIBuilder.h"
27 #include "llvm/IR/DebugInfoMetadata.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/Function.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/LLVMContext.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/IR/Type.h"
34 #include "llvm/InitializePasses.h"
35 #include "llvm/Pass.h"
36 #include "llvm/Support/DJB.h"
37 #include "llvm/Support/Path.h"
38 #include "llvm/Transforms/Utils/ModuleUtils.h"
39 
40 using namespace llvm;
41 
42 #define DEBUG_TYPE "jmc-instrument"
43 
44 namespace {
45 struct JMCInstrumenter : public ModulePass {
46   static char ID;
47   JMCInstrumenter() : ModulePass(ID) {
48     initializeJMCInstrumenterPass(*PassRegistry::getPassRegistry());
49   }
50   bool runOnModule(Module &M) override;
51 };
52 char JMCInstrumenter::ID = 0;
53 } // namespace
54 
55 INITIALIZE_PASS(
56     JMCInstrumenter, DEBUG_TYPE,
57     "Instrument function entry with call to __CheckForDebuggerJustMyCode",
58     false, false)
59 
60 ModulePass *llvm::createJMCInstrumenterPass() { return new JMCInstrumenter(); }
61 
62 namespace {
63 const char CheckFunctionName[] = "__CheckForDebuggerJustMyCode";
64 
65 std::string getFlagName(DISubprogram &SP, bool UseX86FastCall) {
66   // absolute windows path:           windows_backslash
67   // relative windows backslash path: windows_backslash
68   // relative windows slash path:     posix
69   // absolute posix path:             posix
70   // relative posix path:             posix
71   sys::path::Style PathStyle =
72       has_root_name(SP.getDirectory(), sys::path::Style::windows_backslash) ||
73               SP.getDirectory().contains("\\") ||
74               SP.getFilename().contains("\\")
75           ? sys::path::Style::windows_backslash
76           : sys::path::Style::posix;
77   // Best effort path normalization. This is to guarantee an unique flag symbol
78   // is produced for the same directory. Some builds may want to use relative
79   // paths, or paths with a specific prefix (see the -fdebug-compilation-dir
80   // flag), so only hash paths in debuginfo. Don't expand them to absolute
81   // paths.
82   SmallString<256> FilePath(SP.getDirectory());
83   sys::path::append(FilePath, PathStyle, SP.getFilename());
84   sys::path::native(FilePath, PathStyle);
85   sys::path::remove_dots(FilePath, /*remove_dot_dot=*/true, PathStyle);
86 
87   // The naming convention for the flag name is __<hash>_<file name> with '.' in
88   // <file name> replaced with '@'. For example C:\file.any.c would have a flag
89   // __D032E919_file@any@c. The naming convention match MSVC's format however
90   // the match is not required to make JMC work. The hashing function used here
91   // is different from MSVC's.
92 
93   std::string Suffix;
94   for (auto C : sys::path::filename(FilePath, PathStyle))
95     Suffix.push_back(C == '.' ? '@' : C);
96 
97   sys::path::remove_filename(FilePath, PathStyle);
98   return (UseX86FastCall ? "_" : "__") +
99          utohexstr(djbHash(FilePath), /*LowerCase=*/false,
100                    /*Width=*/8) +
101          "_" + Suffix;
102 }
103 
104 void attachDebugInfo(GlobalVariable &GV, DISubprogram &SP) {
105   Module &M = *GV.getParent();
106   DICompileUnit *CU = SP.getUnit();
107   assert(CU);
108   DIBuilder DB(M, false, CU);
109 
110   auto *DType =
111       DB.createBasicType("unsigned char", 8, dwarf::DW_ATE_unsigned_char,
112                          llvm::DINode::FlagArtificial);
113 
114   auto *DGVE = DB.createGlobalVariableExpression(
115       CU, GV.getName(), /*LinkageName=*/StringRef(), SP.getFile(),
116       /*LineNo=*/0, DType, /*IsLocalToUnit=*/true, /*IsDefined=*/true);
117   GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
118   DB.finalize();
119 }
120 
121 FunctionType *getCheckFunctionType(LLVMContext &Ctx) {
122   Type *VoidTy = Type::getVoidTy(Ctx);
123   PointerType *VoidPtrTy = Type::getInt8PtrTy(Ctx);
124   return FunctionType::get(VoidTy, VoidPtrTy, false);
125 }
126 
127 Function *createDefaultCheckFunction(Module &M, bool UseX86FastCall) {
128   LLVMContext &Ctx = M.getContext();
129   const char *DefaultCheckFunctionName =
130       UseX86FastCall ? "_JustMyCode_Default" : "__JustMyCode_Default";
131   // Create the function.
132   Function *DefaultCheckFunc =
133       Function::Create(getCheckFunctionType(Ctx), GlobalValue::ExternalLinkage,
134                        DefaultCheckFunctionName, &M);
135   DefaultCheckFunc->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
136   DefaultCheckFunc->addParamAttr(0, Attribute::NoUndef);
137   if (UseX86FastCall)
138     DefaultCheckFunc->addParamAttr(0, Attribute::InReg);
139 
140   BasicBlock *EntryBB = BasicBlock::Create(Ctx, "", DefaultCheckFunc);
141   ReturnInst::Create(Ctx, EntryBB);
142   return DefaultCheckFunc;
143 }
144 } // namespace
145 
146 bool JMCInstrumenter::runOnModule(Module &M) {
147   bool Changed = false;
148   LLVMContext &Ctx = M.getContext();
149   Triple ModuleTriple(M.getTargetTriple());
150   bool IsMSVC = ModuleTriple.isKnownWindowsMSVCEnvironment();
151   bool IsELF = ModuleTriple.isOSBinFormatELF();
152   assert((IsELF || IsMSVC) && "Unsupported triple for JMC");
153   bool UseX86FastCall = IsMSVC && ModuleTriple.getArch() == Triple::x86;
154   const char *const FlagSymbolSection = IsELF ? ".just.my.code" : ".msvcjmc";
155 
156   GlobalValue *CheckFunction = nullptr;
157   DenseMap<DISubprogram *, Constant *> SavedFlags(8);
158   for (auto &F : M) {
159     if (F.isDeclaration())
160       continue;
161     auto *SP = F.getSubprogram();
162     if (!SP)
163       continue;
164 
165     Constant *&Flag = SavedFlags[SP];
166     if (!Flag) {
167       std::string FlagName = getFlagName(*SP, UseX86FastCall);
168       IntegerType *FlagTy = Type::getInt8Ty(Ctx);
169       Flag = M.getOrInsertGlobal(FlagName, FlagTy, [&] {
170         // FIXME: Put the GV in comdat and have linkonce_odr linkage to save
171         //        .msvcjmc section space? maybe not worth it.
172         GlobalVariable *GV = new GlobalVariable(
173             M, FlagTy, /*isConstant=*/false, GlobalValue::InternalLinkage,
174             ConstantInt::get(FlagTy, 1), FlagName);
175         GV->setSection(FlagSymbolSection);
176         GV->setAlignment(Align(1));
177         GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
178         attachDebugInfo(*GV, *SP);
179         return GV;
180       });
181     }
182 
183     if (!CheckFunction) {
184       Function *DefaultCheckFunc =
185           createDefaultCheckFunction(M, UseX86FastCall);
186       if (IsELF) {
187         DefaultCheckFunc->setName(CheckFunctionName);
188         DefaultCheckFunc->setLinkage(GlobalValue::WeakAnyLinkage);
189         CheckFunction = DefaultCheckFunc;
190       } else {
191         assert(!M.getFunction(CheckFunctionName) &&
192                "JMC instrument more than once?");
193         auto *CheckFunc = cast<Function>(
194             M.getOrInsertFunction(CheckFunctionName, getCheckFunctionType(Ctx))
195                 .getCallee());
196         CheckFunc->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
197         CheckFunc->addParamAttr(0, Attribute::NoUndef);
198         if (UseX86FastCall) {
199           CheckFunc->setCallingConv(CallingConv::X86_FastCall);
200           CheckFunc->addParamAttr(0, Attribute::InReg);
201         }
202         CheckFunction = CheckFunc;
203 
204         StringRef DefaultCheckFunctionName = DefaultCheckFunc->getName();
205         appendToUsed(M, {DefaultCheckFunc});
206         Comdat *C = M.getOrInsertComdat(DefaultCheckFunctionName);
207         C->setSelectionKind(Comdat::Any);
208         DefaultCheckFunc->setComdat(C);
209         // Add a linker option /alternatename to set the default implementation
210         // for the check function.
211         // https://devblogs.microsoft.com/oldnewthing/20200731-00/?p=104024
212         std::string AltOption = std::string("/alternatename:") +
213                                 CheckFunctionName + "=" +
214                                 DefaultCheckFunctionName.str();
215         llvm::Metadata *Ops[] = {llvm::MDString::get(Ctx, AltOption)};
216         MDTuple *N = MDNode::get(Ctx, Ops);
217         M.getOrInsertNamedMetadata("llvm.linker.options")->addOperand(N);
218       }
219     }
220     // FIXME: it would be nice to make CI scheduling boundary, although in
221     //        practice it does not matter much.
222     auto *CI = CallInst::Create(getCheckFunctionType(Ctx), CheckFunction,
223                                 {Flag}, "", &*F.begin()->getFirstInsertionPt());
224     CI->addParamAttr(0, Attribute::NoUndef);
225     if (UseX86FastCall) {
226       CI->setCallingConv(CallingConv::X86_FastCall);
227       CI->addParamAttr(0, Attribute::InReg);
228     }
229 
230     Changed = true;
231   }
232   return Changed;
233 }
234