1 //===- ForceFunctionAttrs.cpp - Force function attrs for debugging --------===//
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 #include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
10 #include "llvm/ADT/StringSwitch.h"
11 #include "llvm/IR/Function.h"
12 #include "llvm/IR/LLVMContext.h"
13 #include "llvm/IR/Module.h"
14 #include "llvm/InitializePasses.h"
15 #include "llvm/Support/Debug.h"
16 #include "llvm/Support/raw_ostream.h"
17 using namespace llvm;
18 
19 #define DEBUG_TYPE "forceattrs"
20 
21 static cl::list<std::string>
22     ForceAttributes("force-attribute", cl::Hidden,
23                     cl::desc("Add an attribute to a function. This should be a "
24                              "pair of 'function-name:attribute-name', for "
25                              "example -force-attribute=foo:noinline. This "
26                              "option can be specified multiple times."));
27 
28 static Attribute::AttrKind parseAttrKind(StringRef Kind) {
29   return StringSwitch<Attribute::AttrKind>(Kind)
30       .Case("alwaysinline", Attribute::AlwaysInline)
31       .Case("builtin", Attribute::Builtin)
32       .Case("cold", Attribute::Cold)
33       .Case("convergent", Attribute::Convergent)
34       .Case("inlinehint", Attribute::InlineHint)
35       .Case("jumptable", Attribute::JumpTable)
36       .Case("minsize", Attribute::MinSize)
37       .Case("naked", Attribute::Naked)
38       .Case("nobuiltin", Attribute::NoBuiltin)
39       .Case("noduplicate", Attribute::NoDuplicate)
40       .Case("noimplicitfloat", Attribute::NoImplicitFloat)
41       .Case("noinline", Attribute::NoInline)
42       .Case("nonlazybind", Attribute::NonLazyBind)
43       .Case("noredzone", Attribute::NoRedZone)
44       .Case("noreturn", Attribute::NoReturn)
45       .Case("nocf_check", Attribute::NoCfCheck)
46       .Case("norecurse", Attribute::NoRecurse)
47       .Case("nounwind", Attribute::NoUnwind)
48       .Case("optforfuzzing", Attribute::OptForFuzzing)
49       .Case("optnone", Attribute::OptimizeNone)
50       .Case("optsize", Attribute::OptimizeForSize)
51       .Case("readnone", Attribute::ReadNone)
52       .Case("readonly", Attribute::ReadOnly)
53       .Case("argmemonly", Attribute::ArgMemOnly)
54       .Case("returns_twice", Attribute::ReturnsTwice)
55       .Case("safestack", Attribute::SafeStack)
56       .Case("shadowcallstack", Attribute::ShadowCallStack)
57       .Case("sanitize_address", Attribute::SanitizeAddress)
58       .Case("sanitize_hwaddress", Attribute::SanitizeHWAddress)
59       .Case("sanitize_memory", Attribute::SanitizeMemory)
60       .Case("sanitize_thread", Attribute::SanitizeThread)
61       .Case("sanitize_memtag", Attribute::SanitizeMemTag)
62       .Case("speculative_load_hardening", Attribute::SpeculativeLoadHardening)
63       .Case("ssp", Attribute::StackProtect)
64       .Case("sspreq", Attribute::StackProtectReq)
65       .Case("sspstrong", Attribute::StackProtectStrong)
66       .Case("strictfp", Attribute::StrictFP)
67       .Case("uwtable", Attribute::UWTable)
68       .Default(Attribute::None);
69 }
70 
71 /// If F has any forced attributes given on the command line, add them.
72 static void addForcedAttributes(Function &F) {
73   for (auto &S : ForceAttributes) {
74     auto KV = StringRef(S).split(':');
75     if (KV.first != F.getName())
76       continue;
77 
78     auto Kind = parseAttrKind(KV.second);
79     if (Kind == Attribute::None) {
80       LLVM_DEBUG(dbgs() << "ForcedAttribute: " << KV.second
81                         << " unknown or not handled!\n");
82       continue;
83     }
84     if (F.hasFnAttribute(Kind))
85       continue;
86     F.addFnAttr(Kind);
87   }
88 }
89 
90 PreservedAnalyses ForceFunctionAttrsPass::run(Module &M,
91                                               ModuleAnalysisManager &) {
92   if (ForceAttributes.empty())
93     return PreservedAnalyses::all();
94 
95   for (Function &F : M.functions())
96     addForcedAttributes(F);
97 
98   // Just conservatively invalidate analyses, this isn't likely to be important.
99   return PreservedAnalyses::none();
100 }
101 
102 namespace {
103 struct ForceFunctionAttrsLegacyPass : public ModulePass {
104   static char ID; // Pass identification, replacement for typeid
105   ForceFunctionAttrsLegacyPass() : ModulePass(ID) {
106     initializeForceFunctionAttrsLegacyPassPass(
107         *PassRegistry::getPassRegistry());
108   }
109 
110   bool runOnModule(Module &M) override {
111     if (ForceAttributes.empty())
112       return false;
113 
114     for (Function &F : M.functions())
115       addForcedAttributes(F);
116 
117     // Conservatively assume we changed something.
118     return true;
119   }
120 };
121 }
122 
123 char ForceFunctionAttrsLegacyPass::ID = 0;
124 INITIALIZE_PASS(ForceFunctionAttrsLegacyPass, "forceattrs",
125                 "Force set function attributes", false, false)
126 
127 Pass *llvm::createForceFunctionAttrsLegacyPass() {
128   return new ForceFunctionAttrsLegacyPass();
129 }
130