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