lib/Transforms/IPO/ForceFunctionAttrs.cpp

   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 }