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("sanitize_memtag", Attribute::SanitizeMemTag) 61 .Case("speculative_load_hardening", Attribute::SpeculativeLoadHardening) 62 .Case("ssp", Attribute::StackProtect) 63 .Case("sspreq", Attribute::StackProtectReq) 64 .Case("sspstrong", Attribute::StackProtectStrong) 65 .Case("strictfp", Attribute::StrictFP) 66 .Case("uwtable", Attribute::UWTable) 67 .Default(Attribute::None); 68 } 69 70 /// If F has any forced attributes given on the command line, add them. 71 static void addForcedAttributes(Function &F) { 72 for (auto &S : ForceAttributes) { 73 auto KV = StringRef(S).split(':'); 74 if (KV.first != F.getName()) 75 continue; 76 77 auto Kind = parseAttrKind(KV.second); 78 if (Kind == Attribute::None) { 79 LLVM_DEBUG(dbgs() << "ForcedAttribute: " << KV.second 80 << " unknown or not handled!\n"); 81 continue; 82 } 83 if (F.hasFnAttribute(Kind)) 84 continue; 85 F.addFnAttr(Kind); 86 } 87 } 88 89 PreservedAnalyses ForceFunctionAttrsPass::run(Module &M, 90 ModuleAnalysisManager &) { 91 if (ForceAttributes.empty()) 92 return PreservedAnalyses::all(); 93 94 for (Function &F : M.functions()) 95 addForcedAttributes(F); 96 97 // Just conservatively invalidate analyses, this isn't likely to be important. 98 return PreservedAnalyses::none(); 99 } 100 101 namespace { 102 struct ForceFunctionAttrsLegacyPass : public ModulePass { 103 static char ID; // Pass identification, replacement for typeid 104 ForceFunctionAttrsLegacyPass() : ModulePass(ID) { 105 initializeForceFunctionAttrsLegacyPassPass( 106 *PassRegistry::getPassRegistry()); 107 } 108 109 bool runOnModule(Module &M) override { 110 if (ForceAttributes.empty()) 111 return false; 112 113 for (Function &F : M.functions()) 114 addForcedAttributes(F); 115 116 // Conservatively assume we changed something. 117 return true; 118 } 119 }; 120 } 121 122 char ForceFunctionAttrsLegacyPass::ID = 0; 123 INITIALIZE_PASS(ForceFunctionAttrsLegacyPass, "forceattrs", 124 "Force set function attributes", false, false) 125 126 Pass *llvm::createForceFunctionAttrsLegacyPass() { 127 return new ForceFunctionAttrsLegacyPass(); 128 } 129